/*
* Copyright (c) 2003, the JUNG Project and the Regents of the University
* of California
* All rights reserved.
*
* This software is open-source under the BSD license; see either
* "license.txt" or
* http://jung.sourceforge.net/license.txt for a description.
*/
package com.davetrudes.jung.client.visualization;


import com.davetrudes.jung.client.algorithms.layout.Layout;
import com.davetrudes.jung.client.common.collections.Transformer;
import com.davetrudes.jung.client.graphics.Dimension;
import com.davetrudes.jung.client.visualization.control.GraphMouseListener;

/**
 * Adds mouse behaviors and tooltips to the graph visualization base class
 *
 * @author Joshua O'Madadhain
 * @author Tom Nelson
 * @author Danyel Fisher
 */
public class VisualizationViewer<V,E> extends BasicVisualizationServer<V,E> {

	protected Transformer<V,String> vertexToolTipTransformer;
	protected Transformer<E,String> edgeToolTipTransformer;
	//protected Transformer<MouseEvent,String> mouseEventToolTipTransformer;

    /**
     * provides MouseListener, MouseMotionListener, and MouseWheelListener
     * events to the graph
     */
//    protected GraphMouse graphMouse;

//    protected MouseListener requestFocusListener = new MouseAdapter() {
//		public void mouseClicked(MouseEvent e) {
//			requestFocusInWindow();
//		}
//    };


    /**
     * Create an instance with passed parameters.
     *
     * @param layout		The Layout to apply, with its associated Graph
     * @param renderer		The Renderer to draw it with
     */
	public VisualizationViewer(Layout<V,E> layout) {
	    this(new DefaultVisualizationModel<V,E>(layout));
	}

    /**
     * Create an instance with passed parameters.
     *
     * @param layout		The Layout to apply, with its associated Graph
     * @param renderer		The Renderer to draw it with
     * @param preferredSize the preferred size of this View
     */
	public VisualizationViewer(Layout<V,E> layout, Dimension preferredSize) {
	    this(new DefaultVisualizationModel<V,E>(layout, preferredSize), preferredSize);
	}

	/**
	 * Create an instance with passed parameters.
	 *
	 * @param model
	 * @param renderer
	 */
	public VisualizationViewer(VisualizationModel<V,E> model) {
	    this(model, new Dimension(600,600));
	}
	/**
	 * Create an instance with passed parameters.
	 *
	 * @param model
	 * @param renderer
	 * @param preferredSize initial preferred size of the view
	 */
	@SuppressWarnings("unchecked")
    public VisualizationViewer(VisualizationModel<V,E> model,   Dimension preferredSize) {
        super(model, preferredSize);
        //addMouseListener(requestFocusListener);
	}

	/**
	 * a setter for the GraphMouse. This will remove any
	 * previous GraphMouse (including the one that
	 * is added in the initMouseClicker method.
	 * @param graphMouse new value
	 */
//	public void setGraphMouse(GraphMouse graphMouse) {
//	    this.graphMouse = graphMouse;
//	    MouseListener[] ml = getMouseListeners();
//	    for(int i=0; i<ml.length; i++) {
//	        if(ml[i] instanceof GraphMouse) {
//	            removeMouseListener(ml[i]);
//	        }
//	    }
//	    MouseMotionListener[] mml = getMouseMotionListeners();
//	    for(int i=0; i<mml.length; i++) {
//	        if(mml[i] instanceof GraphMouse) {
//	            removeMouseMotionListener(mml[i]);
//	        }
//	    }
//	    MouseWheelListener[] mwl = getMouseWheelListeners();
//	    for(int i=0; i<mwl.length; i++) {
//	        if(mwl[i] instanceof GraphMouse) {
//	            removeMouseWheelListener(mwl[i]);
//	        }
//	    }
//	    addMouseListener(graphMouse);
//	    addMouseMotionListener(graphMouse);
//	    addMouseWheelListener(graphMouse);
//	}

	/**
	 * @return the current <code>GraphMouse</code>
	 */
//	public GraphMouse getGraphMouse() {
//	    return graphMouse;
//	}

	/**
	 * This is the interface for adding a mouse listener. The GEL
	 * will be called back with mouse clicks on vertices.
	 * @param gel
	 */
	public void addGraphMouseListener( GraphMouseListener<V> gel ) {
		//addMouseListener( new MouseListenerTranslator<V,E>( gel, this ));
	}

	/**
	 * Override to request focus on mouse enter, if a key listener is added
	 * @see java.awt.Component#addKeyListener(java.awt.event.KeyListener)
	 */
//	public synchronized void addKeyListener(KeyListener l) {
//		super.addKeyListener(l);
////		setFocusable(true);
////		addMouseListener(requestFocusListener);
//	}

	/**
	 * @param edgeToolTipTransformer the edgeToolTipTransformer to set
	 */
	public void setEdgeToolTipTransformer(
			Transformer<E, String> edgeToolTipTransformer) {
		this.edgeToolTipTransformer = edgeToolTipTransformer;
//		ToolTipManager.sharedInstance().registerComponent(this);
	}

	/**
	 * @param mouseEventToolTipTransformer the mouseEventToolTipTransformer to set
	 */
//	public void setMouseEventToolTipTransformer(
//			Transformer<MouseEvent, String> mouseEventToolTipTransformer) {
//		this.mouseEventToolTipTransformer = mouseEventToolTipTransformer;
//		ToolTipManager.sharedInstance().registerComponent(this);
//	}

	/**
	 * @param vertexToolTipTransformer the vertexToolTipTransformer to set
	 */
	public void setVertexToolTipTransformer(
			Transformer<V, String> vertexToolTipTransformer) {
		this.vertexToolTipTransformer = vertexToolTipTransformer;
		//ToolTipManager.sharedInstance().registerComponent(this);
	}

    /**
     * called by the superclass to display tooltips
     */
//    public String getToolTipText(MouseEvent event) {
//        Layout<V,E> layout = getGraphLayout();
//        Point2D p = null;
//        if(vertexToolTipTransformer != null) {
//            p = event.getPoint();
//            	//renderContext.getBasicTransformer().inverseViewTransform(event.getPoint());
//            V vertex = getPickSupport().getVertex(layout, p.getX(), p.getY());
//            if(vertex != null) {
//            	return vertexToolTipTransformer.transform(vertex);
//            }
//        }
//        if(edgeToolTipTransformer != null) {
//        	if(p == null) p = renderContext.getMultiLayerTransformer().inverseTransform(Layer.VIEW, event.getPoint());
//            E edge = getPickSupport().getEdge(layout, p.getX(), p.getY());
//            if(edge != null) {
//            	return edgeToolTipTransformer.transform(edge);
//            }
//        }
//        if(mouseEventToolTipTransformer != null) {
//        	return mouseEventToolTipTransformer.transform(event);
//        }
//        return super.getToolTipText(event);
//    }

    /**
     * a convenience type to represent a class that
     * processes all types of mouse events for the graph
     */
//    public interface GraphMouse extends MouseListener, MouseMotionListener, MouseWheelListener {}

}
